// 泛型： 可以使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据。 这样用户就可以以自己的数据类型来使用组件。

// function identity<U>(args: U): U {
//   return args;
// }

// identity<number>(1)

// identity<string>('1231231')

// identity<boolean>(true)

// 使用泛型变量

// function loggingIdentity<T>(arg: Array<T>): Array<T> {
//   console.log(arg.length); // Error: T doesn't have .length
//   return arg;
// }
// loggingIdentity<number>([1, 2, 3, 4]);

// 泛型类型

// function animal<T>(args: T): T {
//   return args;
// }

// let add: <T>(args: T) => T   = animal

// 泛型接口

// interface User<T> {
//   name: string;
//   age: T;
// }

// const u1: User<number> = {
//   name: "张三",
//   age: 18,
// };

// const u2: User<string> = {
//   name: "李四",
//   age: "18",
// };

// const arr: Array<number> = [1, 2, 3, 4, 5];

// interface MyArray<T> {
//   [propsName: number]: T;
// }

// const arr1: MyArray<string> = ["1", "2", "3"];

// const arrr2: MyArray<boolean | number> = [1, 2, 3, true, false];

// const arrr3: Array<boolean | number> = [1, 2, 3, true, false];

// function add(...arr: number[]): number {
//   return arr.reduce((p, n) => {
//     return p + n;
//   });
// }

// const s = add(1, 2, 3, 4, 5);
// console.log(s);

// 泛型类

// class Index<T, U> {
//   name: T;
//   age: U;
//   constructor(name: T, age: U) {
//     this.name = name;
//     this.age = age;
//   }
// }

// new Index<string, string>("123", '18');

// 泛型约束
// interface Len {
//   length: number;
// }

// function t<T extends Len>(args: T): T {
//   return args;
// }

// t<number>(1);
// t<string>("123");
// t<number[]>([1, 2, 3]);
// t({ a: 1, b: 2, length: 2 })


interface Father {
	name: string
	id: string
	desc: string
}


interface Son extends Father {
	age: number
	like: string[]
}


const s1: Son = {
	name: '儿子',
	id: '1010',
	desc: '123',
	age: 18,
	like: ['']
}